﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.IO;

//#if (!WINDOWS_PHONE)
//  using Microsoft.Xna.Framework.Storage;
//#else
//using System.IO.IsolatedStorage;
//#endif


using TDBaseDataLibrary;
using TDEngineLibrary;
namespace Taoist
{

   // class wavestate
   // {
   //     public int nwave;
   //     public int enemycount;
   //     public List<Enemy> Enemy;
   // }
    
   // class level_resource
   // {
   //     public int force;
   //     public int lift;
   // }
   // class Kongfu
   // {
   //     TDRenderLibrary.SpriteDef sprite;
   //     KeyNode prvkey;
   // }
   // class KeyNode
   // {
   //     public Keys key;
   //     public int time;
   //     public bool bend;

   //     //功夫
   //     public Kongfu kongfu;

   //     //后一键
   //     public KeyNode[] keynext;
   //     //前一键
   //     KeyNode keyprev;
   //     public int GetNextCount()
   //     {
   //         return keynext.Length;
   //     }
   // }
   // class keyFun
   // {
   //     public keyFun()
   //     {
   //     }
   //     KeyNode[] keyInfo;
   // }
   // class kongfu_system
   // {
   //     //
   //     KeyNode keysroot;
   //     Kongfu[] kongfu;
   //     bool bproc;
   //     float lastkeytime;
   //     public kongfu_system()
   //     {
   //     }
   //     KeyNode keyCur;

   //     public KeyNode getcurkey()
   //     {
   //         return keyCur;
   //     }
   //     public bool Update(GameTime gametime,Keys k)
   //     {
   //         if (kongfu == null)
   //             return false;
   //         float ftime = (float)gametime.ElapsedGameTime.TotalMilliseconds - lastkeytime;
   //         if (bproc)
   //         {
   //             if (ftime > 250)
   //             {
   //                 bproc = false;
   //             }
   //         }
   //         if (k != Keys.None)
   //         {
   //             KeyNode kNode = getcurkey();
   //             if (kNode.key == k)
   //             {
   //             }
   //             else
   //             {
   //                 bool bok = tracenext(null, k);
   //                 if (bok)
   //                 {
   //                     Kongfu kf = HitKongfu();
   //                     if (kongfu != null)
   //                     {
   //                         bproc = false;
   //                     }
   //                     else
   //                         lastkeytime = (float)gametime.ElapsedGameTime.TotalMilliseconds;
   //                 }
   //                 else
   //                 {
   //                     bproc = false;
   //                 }
   //             }
   //         }
   //         return bproc;
   //     }
   //     public bool tracenext(KeyNode curK,Keys k)
   //     {
   //         if (curK == null)
   //             curK = keyCur;
   //         if (curK == null)
   //         {
   //             curK = keysroot;
   //         }
   //         int size = curK.GetNextCount();
   //         for (int i = 0; i < size; i++)
   //         {

   //             if (curK.keynext[i].key == k)
   //             {
   //                 keyCur = curK.keynext[i];
   //                 return true;
   //             }
   //         }
   //         keyCur = null;
   //         return false;
   //     }
   //     public Kongfu HitKongfu()
   //     {
   //         return keyCur.kongfu;
   //     }
   //     KeyNode findnext(KeyNode curK, Keys k)
   //     {
   //         if (curK == null)
   //             curK = keyCur;
   //         if (curK == null)
   //         {
   //             curK = keysroot;
   //         }
   //         int size = curK.GetNextCount();
   //         for (int i = 0; i < size; i++)
   //         {

   //             if (curK.keynext[i].key == k)
   //             {
   //                 return curK.keynext[i];
   //             }
   //         }
   //         return null;
   //     }
   // }
   // class Hero:Enemy
   // {
   //     string  szName;          //名称
   //     string  szDescript;      //描述
   //     enumHeroState state;
   //     float     statetime;
   //     float       lastkeytime;
   //     kongfu_system kongfusys;
   //     //英雄类
   //     Stack<Keys> stackKeys;
   //     bool        bkeybegin;
   //     public Hero(string szid, levelpath lpath, float fstarttime):base(szid,lpath,fstarttime)
   //     {
   //         stackKeys = new Stack<Keys>();
   //         bkeybegin = false;
   //         pos.X = 100;
   //         pos.Y = 100;
   //         kongfusys = new kongfu_system();
   //     }
   //     public bool traceSingleKey(Keys k)
   //     {
   //         if (k == Keys.Up)
   //         {
   //             direct = 0;
   //             pos.Y -= 1;
   //         }
   //         else if (k == Keys.Down)
   //         {
   //             pos.Y += 1;
   //         }
   //         else if (k == Keys.Right)
   //         {
   //             direct = 2;
   //             pos.X += 1;
   //         }
   //         else if (k == Keys.Left)
   //         {
   //             direct = 3;
   //             pos.X -= 1;
   //         }
   //         return true;
   //     }
   //     public override bool  update(GameTime gametime)
   //     {
   //         KeyboardState keystate = Keyboard.GetState();
   //         float ftime = (float)gametime.ElapsedGameTime.TotalMilliseconds - lastkeytime;
   //         Keys[] k = keystate.GetPressedKeys();

   //         if (k.Length != 0)
   //         {
   //             bool bkeybegin = kongfusys.Update(gametime, k[0]);


   //             if (!bkeybegin && k[0] != Keys.None)
   //             {
   //                 traceSingleKey(k[0]);
   //             }
   //         }

   //         int ntime = (int)(gametime.TotalGameTime.TotalMilliseconds - time);
   //         int nindex = ntime / 200;
   //         nimgindex = nindex % 2 + 11;

   //         return true;
   //     }
   //     public void Draw(GraphicsDeviceManager graphics, GameTime gameTime, SpriteBatch spriteBatch,int OffsetX,int OffsetY,Color color)
   //     {
   //         Vector2 v = new Vector2(pos.X + OffsetX, pos.Y + OffsetY);
   //         Sprite.Draw(graphics, gameTime, spriteBatch, nimgindex, v, 0.0f, (int)lift * 100 / eclass.get_attribute(enumattr.attr_lift), color);
   //     }
   // }
   //     class levelpath
   // {
   //     line[] linearray;
   //     public levelpath(List<int> listIndex, int scale, int nWidth, int nHeight)
   //     {
   //         List<TDLevelPoint> pathkey = new List<TDLevelPoint>();
   //         int nCount = listIndex.Count;
   //         for (int i = 0; i < nCount; i++)
   //         {
   //             int nIndex = listIndex[i];
   //             TDLevelPoint pPoint = new TDLevelPoint();
   //             pPoint.X = (nIndex % nWidth) * scale;
   //             pPoint.Y = (nIndex / nWidth) * scale;
   //             pathkey.Add(pPoint);
   //         }
   //         MakePath(pathkey);
   //     }
   //     void MakePath(List<TDLevelPoint> pathkey)
   //     {
   //           int ncount = pathkey.Count;
   //         linearray = new line[ncount - 1];
   //         for (int i = 0; i < ncount - 1; i++)
   //         {
   //             linearray[i] = new line();
   //             linearray[i].start.X = pathkey.ElementAt(i).X;//.ElementAt(i);
   //             linearray[i].start.Y = pathkey.ElementAt(i).Y;
   //             linearray[i].end.X = pathkey.ElementAt(i + 1).X;//.ElementAt(i + 1);
   //             linearray[i].end.Y = pathkey.ElementAt(i + 1).Y;
   //             linearray[i].disx = linearray[i].end.X - linearray[i].start.X;
   //             linearray[i].disy = linearray[i].end.Y - linearray[i].start.Y;
   //             float disall = (float)Math.Sqrt(linearray[i].disx * linearray[i].disx + linearray[i].disy * linearray[i].disy);
   //             linearray[i].cosa = linearray[i].disx / disall;
   //             int xo = linearray[i].end.X - linearray[i].start.X;
   //             int yo = linearray[i].end.Y - linearray[i].start.Y;
   //             if (yo == 0)
   //             {
   //                 if (xo > 0)
   //                 {
   //                     linearray[i].direct = 5;
   //                 }
   //                 else if (xo < 0)
   //                 {
   //                     linearray[i].direct = 4;
   //                 }

   //             }
   //             else if (Math.Abs(xo / yo) > 0.5 && Math.Abs(xo / yo) < 2.0)
   //             {
   //                 if (xo > 0 && yo > 0)
   //                 {
   //                     linearray[i].direct = 3;
   //                 }
   //                 else if (xo > 0 && yo < 0)
   //                 {
   //                     linearray[i].direct = 1;
   //                 }
   //                 else if (xo < 0 && yo > 0)
   //                 {
   //                     linearray[i].direct = 0;
   //                 }
   //                 else if (xo < 0 && yo < 0)
   //                 {
   //                     linearray[i].direct = 2;
   //                 }
   //             }
   //             else
   //             {
   //                 if (yo > 0 && Math.Abs(yo) > Math.Abs(xo))
   //                 {
   //                     linearray[i].direct = 7;
   //                 }
   //                 if (xo > 0 && Math.Abs(xo) > Math.Abs(yo))
   //                 {
   //                     linearray[i].direct = 5;
   //                 }
   //                 if (xo < 0 && Math.Abs(xo) > Math.Abs(yo))
   //                 {
   //                     linearray[i].direct = 4;
   //                 }
   //                 if (yo < 0 && Math.Abs(yo) > Math.Abs(xo))
   //                 {
   //                     linearray[i].direct = 6;
   //                 }
   //             }
   //             if (Math.Abs(xo - yo) < xo / 2)
   //             {

   //             }
   //             else
   //             {
   //                 if (xo > 0 && yo > 0)
   //                 {
   //                     if (xo > yo)
   //                     {
   //                         linearray[i].direct = 5;
   //                     }
   //                     else
   //                     {
   //                         linearray[i].direct = 7;
   //                     }
   //                 }
   //                 if (xo > 0 && yo > 0)
   //                 {
   //                     if (xo > yo)
   //                     {
   //                         linearray[i].direct = 5;
   //                     }
   //                     else
   //                     {
   //                         linearray[i].direct = 7;
   //                     }
   //                 }
   //             }
   //         }
   //     }
   //     public levelpath(List<TDLevelPoint> pathkey)
   //     {
   //         MakePath(pathkey);
   //     }
   //     public bool MakePath(List<int> listIndex, int scale, int nWidth, int nHeight)
   //     {
   //         List<TDLevelPoint> pathkey = new List<TDLevelPoint>();
   //         int nCount = listIndex.Count;
   //         for (int i = 0; i < nCount; i++)
   //         {
   //             int nIndex = listIndex[0];
   //             pathkey[i] = new TDLevelPoint();
   //             pathkey[i].X = (nIndex % nWidth) * scale;
   //             pathkey[i].Y = (nIndex / nWidth) * scale;
   //         }
   //         MakePath(pathkey);
   //         return true;

   //         //int Count = listIndex.Count;
   //         //linearray = new line[Count];

   //         //linearray[0] = new line();
   //         //int nIndex = listIndex[0];
   //         //linearray[0].start.X = (nIndex % nWidth) * scale;
   //         //linearray[0].start.Y = (nIndex / nWidth) * scale;
            
   //         //for (int i = 1; i < Count; i++)
   //         //{
   //         //    int nNewIndex = listIndex[i];
   //         //    linearray[i - 1].end.X = (nNewIndex % nWidth) * scale;
   //         //    linearray[i - 1].end.Y = (nNewIndex / nWidth) * scale;
   //         //    linearray[i - 1].disx = linearray[i - 1].end.X - linearray[i - 1].start.X;
   //         //    linearray[i - 1].disy = linearray[i - 1].end.Y - linearray[i - 1].start.Y;

   //         //    float len = 0;
   //         //    if(linearray[i - 1].disx == 0 || linearray[i - 1].disy == 0)
   //         //    {
   //         //        len = 1 * scale;
   //         //    }
   //         //    else
   //         //    {
   //         //        len = 1.414f * scale;
   //         //    }
   //         //    linearray[i - 1].cosa = linearray[i - 1].disx/len;
   //         //    linearray[i - 1].direct = 1;
   //         //    linearray[i] = new line();
   //         //    linearray[i].start.X = linearray[i - 1].end.X;
   //         //    linearray[i].start.Y = linearray[i - 1].end.Y;
   //         //}
   //         //return true;
   //     }
   //     public bool getpos(ref Vector2 pos, ref int k, ref float t, ref int direct, float timeescape, float speed)
   //     {
   //         float t2 = 0;
   //         float ftime = timeescape / 1000;
   //         if (k >= linearray.Count())
   //             return false;
   //         do
   //         {
   //             if(linearray[k].disx != 0)
   //                 t2 = (speed * ftime * linearray[k].cosa) / linearray[k].disx + t;
   //             else
   //                 t2 = (float)(speed * ftime) / Math.Abs(linearray[k].disy) + t;
   //             if (t2 <= 1 && t2 >= -1)
   //             {
   //                 t = t2;
   //                 pos.X = (int)(t * linearray[k].disx + linearray[k].start.X);
   //                 pos.Y = (int)(t * linearray[k].disy + linearray[k].start.Y);
   //                 direct = linearray[k].direct;
   //                 return true;
   //             }
   //             if (linearray[k].cosa != 0)
   //                 ftime -= (1 - t) * linearray[k].disx / (linearray[k].cosa * speed);
   //             else
   //                 ftime -= (1 - t) * linearray[k].disy /speed;
   //             k++;
   //             t = 0;
                
   //         }
   //         while (k < linearray.Count());
   //         return false;
   //     }
   // }
   // class WaveConfig
   // {
   //     public WaveConfig()
   //     {
   //         maxcount = 0;
   //     }
   //     public string name;
   //     public int maxcount;
   // }
   // class levelconfig
   // {
   //     public TDLevelConfig config;
   ////     string name;
   ////     string descript;

   //     //单元
   //     //Byte[] CellBuffer;
   //     //int nCellWidth;
   //     //int nCellHeight;

   //     //Byte[] SurfaceBuffer;
   //     //int nSurfaceWidth;
   //     //int nSurfaceHeight;

   //     //UInt32[] pCellBuffer;
   //     public TDMap m_Map;
   //     TDRenderLibrary.SpriteDef[] spriteDef;
   //     GameSprite gsprite;
   //     EnemySprite enemySprite;
   //     TDAltar levelaltar;
   //     public Texture2D level_map = null;
   //     public Texture2D level_info = null;
   //     static public Texture2D controlPal;
   //     level_resource resource;
   //     SpriteFont leveltimefont;
   //     string strMouse;
   //     public levelpath path;
   //     int nCurWave;
   //     //public List<WaveConfig> WaveList;
   //     public List<Enemy> enemyList;
   //     public List<Towner> townerList;
   //     public Hero     hero;
   //     List<int> m_Path = new List<int>();
   //     ControlPal m_Pal;

   //     //当前英雄谷
   //     int nCurHero;


   //     int enginer;
   //     int lift;
   //     int enemycount;
   //     ContentManager contentRef;
        
   //     float DelayTime;
   //     float starttime;
   //     float fgentime;
   //     float curtime;
   //     float fwavegaptime;
   //     float fcurgaptime;
   //     bool bbegin;

   //     levelstate LevelState;
   //     wavestate state;
   //     bool blbuttondown;
   //     bool brbuttondown;
   //     bool blhitcontrol;
   //     bool bdragmap;
   //     Point lbuttondown_pos;
   //     public Point map_Offset;
   //     Point mapoffset_start;
   //     char[] sperate;
   //     TDObjectMap m_ObjectMap;
   //     public Texture2D roadtex;
   //     public TDWorld m_World;

   //     public Texture2D Level_Map
   //     {
   //         get{return level_map;}
   //     }
   //     public levelconfig()
   //     {
   //         blbuttondown = false;
   //         brbuttondown = false;
   //         sperate = new char[3];
   //         sperate[0] = '(';
   //         sperate[1] = ',';
   //         sperate[2] = ')';
   //         bdragmap = false;
   //         lift = 100;
   //         enemycount = 20;
   //         nCurWave = -1;
   //         curtime = 0;
   //         fwavegaptime = 0;
   //         fcurgaptime = 0;
   //         starttime = 0;
   //         map_Offset.X = 0;
   //         map_Offset.Y = 0;
   //         LevelState = levelstate.levelstate_begin;
   //         DelayTime = 3000;
   //         fgentime = 1000;
   //         resource = new level_resource();
   //         resource.lift = 0;
   //         resource.force = 0;
   //     }
   //     public void Init()
   //     {
   //     }
   //     public void LoadLevel(String strLevelName)
   //     {
   //     }
   //     public void LoadContent(ContentManager content)
   //     {
   //         contentRef = content;
   //         leveltimefont = content.Load<SpriteFont>("SpriteFont_towner");
   //         Texture2D tex  = content.Load<Texture2D>("allman");
   //         roadtex = content.Load<Texture2D>("A");
            
   //         Vector2 center = new Vector2(30,50);
   //         spriteDef = new SpriteDef[2];
            
            
   //         //gsprite = new GameSprite(tex, 200, true, 64, 64, 13, center);
   //         EnemySprite.liftbound = content.Load<Texture2D>("liftbound");
   //         EnemySprite.liftshow = content.Load<Texture2D>("liftshow");
   //         Vector2 vExCenter = new Vector2(40,40);
   //         Texture2D texexplosion = content.Load<Texture2D>("Explosion");
   //         Enemy.Explosion = new GameSprite(texexplosion, 200, true, 80, 1600, 20, vExCenter);
   //         enemySprite = new EnemySprite(tex, 200, true, 64, 64, 13, center);
   //         enemyList = new List<Enemy>();
   //         townerList = new List<Towner>();
            
   //         levelaltar = new TDAltar(resource);
   //         levelaltar.LoadContent(content);
   //         if(m_Map==null)
   //             m_Map = new TDMap();
   //         m_Map.LoadContent(content);
   //         int nHeight = 480;
   //         m_ObjectMap = new TDObjectMap(nHeight);
   //         m_Map.CreateMapObject(m_ObjectMap);

   //         m_Pal = new ControlPal();
   //         m_Pal.LoadContent(content);
   //         //System.IO.Stream stream = TitleContainer.OpenStream("TDmap.dat");
   //         //BinaryReader br = new BinaryReader(stream);
   //         //map_header mapheader = new map_header();

   //         //mapheader.version = br.ReadInt32();
   //         //mapheader.cell_width = br.ReadInt32();
   //         //mapheader.cell_height = br.ReadInt32();
   //         //mapheader.cell_offset = br.ReadInt32();
   //         //mapheader.cell_length = br.ReadInt32();
   //         //mapheader.surface_width = br.ReadInt32();
   //         //mapheader.surface_height = br.ReadInt32();
   //         //mapheader.surface_offset = br.ReadInt32();
   //         //mapheader.surface_length = br.ReadInt32();
   //         //mapheader.backimg_width = br.ReadInt32();
   //         //mapheader.backimg_height = br.ReadIn、t32();
   //         //mapheader.backimg_offset = br.ReadInt32();
   //         //mapheader.backimg_length = br.ReadInt32();
   //         //mapheader.surface_cell = br.ReadInt32();
   //         //mapheader.cell_pixcel = br.ReadInt32();

   //         //nCellWidth = mapheader.cell_width;
   //         //nCellHeight = mapheader.cell_height;
   //         //CellBuffer = new Byte[mapheader.cell_width * mapheader.cell_height];
   //         //nSurfaceWidth = mapheader.surface_width;
   //         //nSurfaceHeight = mapheader.surface_height;
   //         //SurfaceBuffer = new Byte[nSurfaceWidth * nSurfaceHeight];
   //         //br.Read(CellBuffer, 0, mapheader.cell_width * mapheader.cell_height);
   //         //br.Read(SurfaceBuffer, 0, nSurfaceWidth * nSurfaceHeight);
   //         ////int len = sizeof(map_header);
   //         //stream.Close();

   //         if (hero == null)
   //         {
   //             hero = new Hero("绿龙", null, (float)0);
   //         }
   //         //Enemy.liftbound = content.Load<Texture2D>("liftbound");
   //         //Enemy.liftshow = content.Load<Texture2D>("liftShow");

   //     }
   //     public void Update(GameTime time,int OffsetX,int OffsetY,Level l)
   //     {

   //         if (LevelState == levelstate.levelstate_begin)
   //         {
   //             DelayTime = 3000;
   //             LevelState = levelstate.levelstate_ready;
   //             curtime = starttime = (float)time.TotalGameTime.TotalMilliseconds;
   //         }
   //         else if (LevelState == levelstate.levelstate_ready)
   //         {
   //             DelayTime = 3000 - (float)(time.TotalGameTime.TotalMilliseconds - starttime);
   //             curtime = (float)time.TotalGameTime.TotalMilliseconds;
   //             if (DelayTime <= 0)
   //             {
   //                 curtime = starttime = (float)time.TotalGameTime.TotalMilliseconds;
   //                 LevelState = levelstate.levelstate_wave;// levelstate_nextvavedescript;
   //             }
   //         }
   //         else if (LevelState == levelstate.levelstate_wave)
   //         {
                
   //             fgentime -= (float)time.ElapsedGameTime.TotalMilliseconds;
   //             fcurgaptime -= (float)time.ElapsedGameTime.TotalMilliseconds;
   //             if ((enemycount == 0 || nCurWave < 0) && fcurgaptime < 0)
   //             {
   //                 nCurWave++;

   //                 if (nCurWave >= config.wavelist.Count)
   //                 {
   //                     LevelState = levelstate.levelstate_scuess;
   //                 }
   //                 else
   //                 {
   //                     enemycount = config.wavelist[nCurWave].count;
   //                     fcurgaptime = fwavegaptime;
   //                 }
   //             }
   //             if (fgentime <= 0 && enemycount > 0)
   //             {
   //                 if (enemyList.Count <= 0)
   //                 {
   //                     TDWaveInfo wave = config.wavelist[nCurWave];
   //                     Enemy e = new Enemy(wave.name, null, (float)time.TotalGameTime.TotalMilliseconds);
   //                     e.SetPosition(this, 405, 4643/*m_Map.m_nDes*/);
   //                     e.m_ptPos.X = 0;
   //                     e.m_ptPos.Y = 0;
   //                     m_ObjectMap.InsertObject(e);
   //                     enemyList.Add(e);
   //                     fgentime = 1000;
   //                     enemycount -= 1;
   //                 }
   //             }
                
   //             for (int i = 0; i < enemyList.Count(); i++)
   //             {
   //                 Enemy e = enemyList.ElementAt(i);
   //                 m_ObjectMap.RemoveObject(e);
   //                 bool bret = e.update(time);

   //                 if (!bret)
   //                 {
   //                     resource.force += e.eclass.get_attribute(enumattr.attr_downforce);
   //                     enemyList.RemoveAt(i);
   //                     lift--;
   //                     i--;
   //                 }
   //                 else
   //                 {
   //                     m_ObjectMap.InsertObject(e);
   //                 }
   //             }
   //             for (int i = 0; i < townerList.Count(); i++)
   //             {
   //                 Towner t = townerList.ElementAt(i);
   //                 t.Update(enemyList,time);
   //             }

   //             //祭坛更新
   //             levelaltar.update(time);
   //             hero.update(time);
                
   //         }
   //         bool bRet = false;
   //         if (LevelState == levelstate.levelstate_wave)
   //         {
   //             bRet = m_Pal.Update(time);
   //         }
   //         if (bRet)
   //             return;
   //         KeyboardState keyState = Keyboard.GetState();
            
   //         MouseState mouseState = Mouse.GetState();
   //         strMouse = String.Format("X={0};Y={1};force = {2}", mouseState.X, mouseState.Y, resource.force);
   //         if (mouseState.RightButton == ButtonState.Pressed && brbuttondown == false)
   //         {
             
   //         }
   //         if (mouseState.LeftButton == ButtonState.Pressed&&blbuttondown == false)
   //         {
   //             Rectangle rtHit = new Rectangle(OffsetX,OffsetY,OffsetX + 737,OffsetY + 494);
   //             if (rtHit.Left < mouseState.X && rtHit.Right > mouseState.X && rtHit.Top < mouseState.Y && rtHit.Bottom > mouseState.Y)
   //             {
   //                 blbuttondown = true;
   //                 lbuttondown_pos.X = mouseState.X;
   //                 lbuttondown_pos.Y = mouseState.Y;
   //                 mapoffset_start = map_Offset;
   //             }
                
   //         }
   //         else if (mouseState.LeftButton == ButtonState.Released && blbuttondown == true)
   //         {
                
   //             if (bdragmap)
   //             {
   //                 bdragmap = false;
   //             }
   //             else if(blbuttondown == true)
   //             {
   //                 int TownerX = -OffsetX + mouseState.X + map_Offset.X;
   //                 int TownerY = -OffsetY + mouseState.Y + map_Offset.Y;

   //                 int ndesX = TownerX / 8;
   //                 int ndesY = TownerY / 8;


   //                 //TDWaveInfo wave = config.wavelist[nCurWave];
   //                 //Enemy e = new Enemy(wave.name, path, (float)time.TotalGameTime.TotalMilliseconds);
   //                 //e.SetPosition(this, ndesY * 100 + ndesX, 4643/*m_Map.m_nDes*/);
   //                 //enemyList.Add(e);
   //                 //fgentime = 1000;
   //                 //enemycount -= 1;

   //                 int nSelectTowner = m_Pal.GetSelectTowner();
   //                 Vector2 pos = new Vector2(TownerX, TownerY);
   //                 if (nSelectTowner < 0)
   //                 {
   //                 }
   //                 else if(nSelectTowner == 0)
   //                 {
   //                     if (resource.force >= ArrowTowner.price)
   //                     {
   //                         ArrowTowner towner = new ArrowTowner(contentRef, pos, m_Map,100);
   //                         townerList.Add(towner);
   //                         resource.force -= ArrowTowner.price;
   //                     }
   //                 }
   //                 else
   //                 {
   //                     if (resource.force >= FireTowner.price)
   //                     {
   //                         FireTowner towner = new FireTowner(contentRef, pos,m_Map,100);
   //                         townerList.Add(towner);
   //                         resource.force -= FireTowner.price;
   //                     }
   //                 }
                    
   //             }
   //             blbuttondown = false;
   //         }
   //         if (blbuttondown == true)
   //         {
   //             if (lbuttondown_pos.X != mouseState.X || lbuttondown_pos.Y != mouseState.Y)
   //             {
   //                 map_Offset.X = mapoffset_start.X + lbuttondown_pos.X - mouseState.X;
   //                 map_Offset.Y = mapoffset_start.Y + lbuttondown_pos.Y - mouseState.Y;
   //                 if (map_Offset.X < 0)
   //                     map_Offset.X = 0;
   //                 if (map_Offset.Y < 0)
   //                     map_Offset.Y = 0;
   //                 if (map_Offset.X > level_map.Width - 737)
   //                     map_Offset.X = level_map.Width - 737;
   //                 if (map_Offset.Y > level_map.Height - 494)
   //                     map_Offset.Y = level_map.Height - 494;
   //                 bdragmap = true;
   //             }
   //         }
   //         //gsprite.Update(time);
   //     }
   //     public void Draw(GraphicsDeviceManager graphics, GameTime gameTime, SpriteBatch spriteBatch,int OffsetX,int OffsetY)
   //     {
   //         Rectangle rtSrc = new Rectangle(0, 0, 32, 32);
   //         Rectangle rtDes = rtSrc;// new Rectangle(OffsetX, OffsetY, graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight);
   //         Vector2 vrotate = new Vector2(32, 32);
   //         spriteBatch.Draw(level_map, rtDes, rtSrc, Color.White);
   //         Random rand = new Random();
   //         rand.Next();
   //         for (int i = 0; i < 15; i++)
   //         {
   //             Rectangle rtLineDes = rtDes;
   //             for (int k = 0; k < 25; k++)
   //             {
   //                 spriteBatch.Draw(TDMap.m_EarthFloor[1, m_Map.m_EarthMap[i * 25 + k]], rtLineDes, rtSrc, Color.White);
   //                 rtLineDes.Offset(32, 0);
   //             }
   //             rtDes.Offset(0, 32);
   //         }


   //         //绘制祭坛
   //         levelaltar.Draw(graphics, gameTime, spriteBatch, OffsetX - map_Offset.X, OffsetY - map_Offset.Y); 
   //         if (LevelState == levelstate.levelstate_ready)
   //         {
   //             Vector2 v = new Vector2(40, 20);
   //             string time = String.Format("Level{0}sec",(int)(DelayTime/1000));
   //             //spriteBatch.DrawString(leveltimefont, time, v, Color.White);
   //         }
   //         if (LevelState == levelstate.levelstate_nextvavedescript)
   //         {
   //             Vector2 v = new Vector2(40, 20);
   //             string time = String.Format("Start", (int)(DelayTime / 1000));
   //             //spriteBatch.DrawString(leveltimefont, time, v, Color.White);
   //         }
   //         if (LevelState == levelstate.levelstate_wave)
   //         {
   //             m_ObjectMap.Draw(graphics, gameTime, spriteBatch, OffsetX - map_Offset.X, OffsetY - map_Offset.Y);
   //             //for (int i = enemyList.Count() - 1; i >= 0; i--)
   //             //{
   //             //    Enemy e = enemyList.ElementAt(i);
   //             //    e.Draw(graphics, gameTime, spriteBatch, OffsetX - map_Offset.X, OffsetY - map_Offset.Y);
   //             //}
   //             //if (hero != null)
   //             //    hero.Draw(graphics, gameTime, spriteBatch, OffsetX - map_Offset.X, OffsetY - map_Offset.Y);
   //             Vector2 v = new Vector2(40, 20);
   //             string time = String.Format("lift:{0}", lift);
   //             //spriteBatch.DrawString(leveltimefont, time, Vector2.Zero, Color.White);
   //             //spriteBatch.DrawString(leveltimefont, strMouse, v, Color.White);
   //             for (int k = townerList.Count() - 1; k >= 0; k--)
   //             {
   //                 Towner towner = (Towner)townerList.ElementAt(k);
   //                 towner.Draw(graphics, gameTime, spriteBatch, OffsetX - map_Offset.X, OffsetY - map_Offset.Y);
   //             }
   //         }

   //         //Rectangle desrt = new Rectangle(0, 0,800, 48);
   //         //Rectangle srcrt = new Rectangle(0, 0, roadtex.Width, roadtex.Height);
   //         //spriteBatch.Draw(roadtex, desrt, srcrt, Color.White);
            
   //         //for (int i = 0; i < m_Map.m_nSurfaceHeight; i++)
   //         //{
   //         //    for (int j = 0; j < m_Map.m_nSurfaceWidth; j++)
   //         //    {
   //         //        int index = i * m_Map.m_nSurfaceWidth + j;
   //         //        if (m_Map.m_SurfaceBuffer[index] != 0)
   //         //        {
   //         //            Rectangle desrt = new Rectangle(j * 48, i * 48, 48, 48);
   //         //            Rectangle srcrt = new Rectangle(0, 0, roadtex.Width, roadtex.Height);
   //         //            desrt.Offset(OffsetX, OffsetY);
   //         //            if(m_Map.GetRoadTex(index)!=null)
   //         //                spriteBatch.Draw(m_Map.GetRoadTex(index), desrt, srcrt, Color.White);
   //         //        }
   //         //    }
   //         //}
   //         m_Pal.Draw(graphics, gameTime, spriteBatch,OffsetX,OffsetY);

   //         //int count = m_Path.Count;
   //         //for (int i = 0; i < count; i++)
   //         //{
   //         //    int pos = m_Path[i];
   //         //    int x = pos % m_Map.m_nCellWidth;
   //         //    int y = pos / m_Map.m_nCellWidth;
   //         //    Rectangle rtDes = new Rectangle(x * 8, y * 8, 8, 8);
   //         //    rtDes.Offset(OffsetX, OffsetY);
   //         //    spriteBatch.Draw(EnemySprite.liftshow, rtDes, Color.White);
   //         //    //Sprite.Draw(graphics, gameTime, spriteBatch, nimgindex, v, 0.0f, (int)lift * 100 / eclass.get_attribute(enumattr.attr_lift), Color.White);
   //         //}
   //         //gsprite.Draw(graphics, gameTime, spriteBatch);
   //     }
   //     public bool loadfromfile(string configfile, float fscalex, float fscaley)
   //     {
   //         //string line;
   //         //using (StreamReader reader = new StreamReader(configfile))
   //         //{
   //         //    List<Point> pathkey = new List<Point>();
   //         //    do
   //         //    {
   //         //        line = reader.ReadLine();
   //         //        if (line == null)
   //         //            break;
   //         //        string[] arraw = line.Split('=');
   //         //        if (arraw[0] == "name")
   //         //        {
   //         //            name = arraw[1];
   //         //        }
   //         //        else if (arraw[0] == "descript")
   //         //        {
   //         //            descript = arraw[1];
   //         //        }
   //         //        else if (arraw[0] == "altar")
   //         //        {

   //         //        }
   //         //        else if (arraw[0] == "WaveGap")
   //         //        {
   //         //            fwavegaptime = int.Parse(arraw[1]);
   //         //        }
   //         //        else if (arraw[0] == "WaveList")
   //         //        {
   //         //            string[] enemytype = arraw[1].Split(';');
   //         //            int nSize = enemytype.GetLength(0);
   //         //            WaveList = new List<WaveConfig>();
   //         //            for (int i = 0; i < nSize; i++)
   //         //            {
   //         //                string[] enemyinfo = enemytype[i].Split(sperate);
   //         //                WaveConfig wave = new WaveConfig();
   //         //                wave.name = enemyinfo[1];
   //         //                wave.maxcount = int.Parse(enemyinfo[2]);
   //         //                WaveList.Add(wave);
   //         //            }
   //         //        }
   //         //        else if (arraw[0] == "startforce")
   //         //        {
   //         //            resource.force = int.Parse(arraw[1]);
   //         //        }
   //         //        else if (arraw[0] == "point")
   //         //        {

   //         //            string[] point = arraw[1].Split(';');
   //         //            int size = point.Length;
   //         //            for (int i = 0; i < size; i++)
   //         //            {
   //         //                string[] xy = point[i].Split(sperate);
   //         //                Point pt = new Point(int.Parse(xy[1]), int.Parse(xy[2]));
   //         //                pt.X = (int)(pt.X);
   //         //                pt.Y = (int)(pt.Y);
   //         //                pathkey.Add(pt);
   //         //            }
   //         //        }

   //         //    } while (line != null);
   //         //    path = new levelpath(pathkey);
   //         //}
   //         return false;
   //     }
   // }
   // class LevelDes
   // {
   //     string levelconfig;
   //     string levelmap;
   //     string levelname;
   //     string levelinfo;
   //     public LevelDes(string config,string name, string map, string info)
   //     {
   //         levelmap = map;
   //         levelname = name;
   //         levelinfo = info;
   //         levelconfig = config;
   //     }
   //     public string  LevelMap
   //     {
   //         get { return levelmap; }
   //     }
   //     public string  LevelName
   //     {
   //         get {return levelname;}
   //     }
   //     public string LevelInfo
   //     {
   //         get { return levelinfo; }
   //     }
   // }
    
   // class Level
   // {
   //     int  m_curLevel;
   //     TDLevelList levellist;
   //     //levelconfig curlevel;
   //     //List<LevelDes> levellist;
   //     Texture2D curmap;
   //     levelconfig curlevel;
   //     Vector2 ScreenSize;
   //     Texture2D level_townerA;
   //     float ScreenScaleX;
   //     float ScreenScaleY;
   //     float frotate;
   //     string strMouse;
   //     ContentManager contentRef;
   //     static Texture2D level_back;
   //     static Texture2D level_control;
   //     static Texture2D level_ArrowIcon;
   //     static Texture2D level_FireIcon;
   //     static Texture2D level_IconSel;
   //     static Point map_start;
   //     public int ctrl_index;
   //     int ctrl_press_index;
   //     Point ctrl_presspt;
   //     Texture2D roadtex;

   //     bool buttondown_ctrl;
       
   //     Towner towner;
   //     Rectangle[] ctrlRect;

        
   //     //敌人
   //     List<Enemy> enemyList;
   //     public Level(ContentManager content,Vector2 SizeScreen,float fScaleX,float fScaleY)
   //     {
   //         ScreenSize = SizeScreen;
   //         ScreenScaleX = fScaleX;
   //         ScreenScaleY = fScaleY;
   //         m_curLevel = -1;
   //         frotate = 0;
   //         map_start.X = 0; //30;
   //         map_start.Y = 0;// 16;
   //         //levellist = new List<LevelDes>();
   //         contentRef = content;
   //         buttondown_ctrl = false;
   //         ctrlRect = new Rectangle[2];
   //         ctrlRect[0] = new Rectangle(110,545,32,32);
   //         ctrlRect[1] = new Rectangle(160,545,32,32);
   //         ctrl_press_index = -1;
   //         ctrl_index = -1;
   //         //mapSystem.init(content);
   //         //背景
   //         level_back = contentRef.Load<Texture2D>("back2");
   //         level_control = contentRef.Load<Texture2D>("control");
   //         level_ArrowIcon = contentRef.Load<Texture2D>("TownerArrowIcon");
   //         level_FireIcon = contentRef.Load<Texture2D>("TownerFireIcon");
   //         level_IconSel = contentRef.Load<Texture2D>("SelIconMask"); 
   //     }
   //     public void LoadContent()
   //     {
   //         //string levelPath;
   //         //string line;
   //         //string XmlPath;
   //         //XmlPath = String.Format("textxml.xml");
   //         //XmlPath = Path.Combine(StorageContainer.TitleLocation, "Content/" + XmlPath);
   //         //XmlInfoReader XmlReader = new XmlInfoReader(XmlPath);
   //         BufferSkills skill;
   //         skill = contentRef.Load<BufferSkills>("testxml");
   //         levellist = contentRef.Load<TDLevelList>("Levels/Level_Info");
   //         roadtex = contentRef.Load<Texture2D>("A");
   //         //using (StreamReader reader = new StreamReader(levelPath))
   //         //{
   //         //    do
   //         //    {
   //         //        line = reader.ReadLine();
   //         //        if (line == null)
   //         //            break;
   //         //        string[] arraw = line.Split(';');
   //         //        LevelDes item = new LevelDes(arraw[3],arraw[0], arraw[1], arraw[2]);
   //         //        levellist.Add(item);
   //         //    } while (line != null);
   //         //}
            
   //     }
   //     public bool LoadNextLevel(ContentManager content)
   //     {
   //         curlevel = new levelconfig();
   //         curlevel.config = content.Load<TDLevelConfig>("Levels/Confused_Config");
   //         curlevel.Init();
   //         //string levelPath;
   //         //levelPath = String.Format("Levels/{0}","confused_config.txt");
   //         //levelPath = Path.Combine(StorageContainer.TitleLocation, "Content/" + levelPath);

   //         m_curLevel++;
   //         //curlevel = new levelconfig();
   //         curlevel.level_map = content.Load<Texture2D>("Levels/" + levellist.LevelList[m_curLevel].levelmap);
   //         //curlevel.loadfromfile(levelPath, ScreenScaleX,ScreenScaleY);
   //         //curlevel.path = new levelpath(curlevel.config.ptlist);
   //         curlevel.LoadContent(content);
   //         level_townerA = content.Load<Texture2D>("TownerArrow");
   //         contentRef = content;
   //         return false;
   //     }
        
   //     public bool ControlPal_Update(GraphicsDeviceManager graphics, GameTime gameTime)
   //     {
   //         MouseState mouseState = Mouse.GetState();
   //         Rectangle rtControl = new Rectangle(0, 500, 800, 100);
   //         if (mouseState.LeftButton == ButtonState.Pressed && buttondown_ctrl == false)
   //         {
   //             if (mouseState.X > rtControl.Left && mouseState.X < rtControl.Right
   //                    && mouseState.Y > rtControl.Top && mouseState.Y < rtControl.Bottom)
   //             {
   //                 for (int i = 0; i < 2; i++)
   //                 {
   //                     if (mouseState.X > ctrlRect[i].Left && mouseState.X < ctrlRect[i].Right
   //                    && mouseState.Y > ctrlRect[i].Top && mouseState.Y < ctrlRect[i].Bottom)
   //                     {
   //                         ctrl_press_index = i;
   //                         buttondown_ctrl = true;
   //                         return true;
   //                     }
   //                 }
   //             }
   //         }
   //         else if (mouseState.LeftButton == ButtonState.Pressed && buttondown_ctrl == true)
   //         {
   //         }
   //         else if (mouseState.LeftButton == ButtonState.Released && buttondown_ctrl == true)
   //         {
   //             for (int i = 0; i < 2; i++)
   //             {
   //                 if (mouseState.X > ctrlRect[i].Left && mouseState.X < ctrlRect[i].Right
   //                && mouseState.Y > ctrlRect[i].Top && mouseState.Y < ctrlRect[i].Bottom)
   //                 {
   //                     if(i == ctrl_press_index)
   //                         ctrl_index = i;
                        
   //                     buttondown_ctrl = false;
   //                     return true;
   //                 }
   //             }
   //             ctrl_press_index = -1;
   //             buttondown_ctrl = false;
   //         }
   //         return false;
   //     }
   //     public void Update(GraphicsDeviceManager graphics, GameTime gameTime)
   //     {
   //         ControlPal_Update(graphics, gameTime);
   //         curlevel.Update(gameTime,map_start.X,map_start.Y,this);
   //         frotate += 0.1f;
            
            
   //     }
   //     public void Draw(GraphicsDeviceManager graphics,GameTime gameTime,SpriteBatch spriteBatch)
   //     {
   //         Rectangle rttownerA = new Rectangle(100, 100, 64, 64);
   //         Rectangle rttownerASrc = new Rectangle(0, 0, 64, 64);
   //         spriteBatch.Begin(SpriteSortMode.Immediate,BlendState.AlphaBlend);
            
   //         curlevel.Draw(graphics, gameTime, spriteBatch, map_start.X, map_start.Y);
   //        // spriteBatch.Draw(level_back, Vector2.Zero, Color.White);
   //         Vector2 vDes = new Vector2(0, 500);

   //         //spriteBatch.Draw(level_control, vDes, Color.White);
   //         //vDes.X += 110;
   //         //vDes.Y += 45;
   //         //spriteBatch.Draw(level_ArrowIcon, vDes, Color.White);
   //         //if (ctrl_index == 0 || ctrl_press_index == 0)
   //         //    spriteBatch.Draw(level_IconSel, vDes, Color.White);
   //         //vDes.X += 50;

   //         //spriteBatch.Draw(level_FireIcon, vDes, Color.White);
   //         //if (ctrl_index == 1 || ctrl_press_index == 1)
   //         //    spriteBatch.Draw(level_IconSel, vDes, Color.White);

   //         //Rectangle desrt = new Rectangle(0, 0, 800, 48);
   //         //Rectangle srcrt = new Rectangle(0, 0, roadtex.Width, roadtex.Height);
   //         //spriteBatch.Draw(roadtex, desrt, srcrt, Color.White);
   //         //spriteBatch.Draw(level_townerA, rttownerA, rttownerASrc, Color.White, frotate, vrotate, SpriteEffects.FlipVertically,0);
            
   //         spriteBatch.End();
   //     }
   // }
}
